package com.hksj.Intelligentmanagement.auth.service;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hksj.Intelligentmanagement.auth.dto.MenuDTO;
import com.hksj.Intelligentmanagement.auth.dto.MenuStatusDTO;
import com.hksj.Intelligentmanagement.auth.entity.Menu;
import com.hksj.Intelligentmanagement.auth.mapper.MenuMapper;
import com.hksj.Intelligentmanagement.auth.vo.MenuVo;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 菜单表 服务类
 * @author chenxingqing
 */
@Service
public class MenuService extends ServiceImpl<MenuMapper, Menu> {

    /**
     * 查询用户分配的权限
     * @param userId = null 时查所有权限
     * @return
     */
    public List<MenuVo> listMenuByUserId(String userId){
        return baseMapper.listMenuByUserId(userId,"0");
    }

    /**
     * 查询所有的菜单权限
     * @param status
     * @return
     */
    public List<MenuVo> listAllMenu(String status){
        return baseMapper.listAllMenu(status); 
    }

    /**
     * 获取所有菜单的权限树 包含禁用的
     * @return
     */
    public List<MenuVo> getAllMenuTree(String status){
        List<MenuVo> allMenu = listAllMenu(status);
        return toMenuTree(allMenu);
    }

    /**
     * 获取用户的菜单权限树
     * @param userId 用户id
     * @return
     */
    public List<MenuVo> getUserMenuTree(String userId){
        List<MenuVo> userMenus = listMenuByUserId(userId);
        for (MenuVo userMenu : userMenus) {
            MenuVo.Meta meta = userMenu.getMetaInstance();
            meta.setTitle(userMenu.getTitle());
            meta.setIcon(userMenu.getIcon());
            meta.setIsHide("0".equals(userMenu.getVisible()) ? false : true);
            meta.setRoles(Arrays.asList(userMenu.getPerms()));
            userMenu.setMeta(meta);
            userMenu.setName(userMenu.getMenuName());
//            userMenu.setComponent(formatComponent(userMenu.getComponent()));
        }
        return toMenuTree(userMenus);
    }

    private String formatComponent(String component) {
        String res = component;
        if (ObjectUtil.isNotEmpty(component)){
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("() => import('").append(component).append("')");
            res = stringBuffer.toString();
        }
        return res;
    }


    /**
     * 获取用户分配的权限在总权限树中选中状态树
     * @param userId
     * @return
     */
    public List<MenuVo> getUserMenuTreeInAll(String userId){
        List<MenuVo> userMenus = listMenuByUserId(userId);
        return getMenuTreeInAll(userMenus);
    }
    /**
     * 获取当前权限集合在总权限集合中的 树型选中状态
     * @param menus 拥有的权限集合
     * @return
     */
    public List<MenuVo> getMenuTreeInAll(List<MenuVo> menus){
        List<MenuVo> allMenus = listAllMenu("0");
        List<String> userMenuIds = menus.stream().map(item -> item.getId()).collect(Collectors.toList());
        for (MenuVo menuVo : allMenus) {
            if (userMenuIds.contains(menuVo.getId())){
                menuVo.setSelected(1);
            }else{
                menuVo.setSelected(0);
            }
        }
        return toMenuTree(allMenus);
    }

    /**
     * 根据菜单列表 构建树型结构
     * @param menus 菜单列表
     * @return
     */
    public List<MenuVo> toMenuTree(List<MenuVo> menus){
        //模拟根节点
        MenuVo root = new MenuVo();
        root.setId("0");
        root = toMenuTree(root,menus);
        return root.getChildList();
    }

    /**
     * 根据菜单列表 构建树型结构
     * @param root 根节点
     * @param menus 菜单列表
     * @return
     */
    private MenuVo toMenuTree(MenuVo root,List<MenuVo> menus){
        //初始化根菜单的子菜单列表
        if (ObjectUtils.isEmpty(root.getChildList())){
            root.setChildList(new ArrayList<>());
        }
        //查找子菜单
        for (MenuVo menu : menus) {
            if (menu.getPid().equals(root.getId())){
                MenuVo treeNode = toMenuTree(menu, menus);
                root.getChildList().add(treeNode);
            }
        }
        return root;
    }

    /**
     * 添加菜单
     * @param menuDTO
     */
    public void createMenu(MenuDTO menuDTO) {
        Menu menu = new Menu();
        BeanUtils.copyProperties(menuDTO,menu);
        this.save(menu);
    }

    /**
     * 修改菜单
     * @param menuDTO
     */
    public void updateMenu(MenuDTO menuDTO) {
        Menu menu = new Menu();
        BeanUtils.copyProperties(menuDTO,menu);
        this.updateById(menu);
    }

    /**
     * 逻辑删除菜单
     * @param id
     */
    public void deleteMenu(String id) {
        this.removeById(id);
    }

    public void switchMenu(MenuStatusDTO menuStatus) {
        Menu menu = new Menu();
        menu.setStatus(menuStatus.getStatus());
        LambdaQueryWrapper<Menu> query = new QueryWrapper<Menu>().lambda()
                .in(Menu::getId, menuStatus.getMenuIds());
        baseMapper.update(menu,query);
    }

    public List<String> listUserPermissionKey(String userId){
        List<MenuVo> menuVos = listMenuByUserId(userId);
        List<String> permsKeyList = menuVos.stream().map(menuVo -> menuVo.getPerms()).collect(Collectors.toList());
        return permsKeyList;
    }
}
